{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Image features exercise\n",
    "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n",
    "\n",
    "We have seen that we can achieve reasonable performance on an image classification task by training a linear classifier on the pixels of the input image. In this exercise we will show that we can improve our classification performance by training linear classifiers not on raw pixels but on features that are computed from the raw pixels.\n",
    "\n",
    "All of your work for this exercise will be done in this notebook.\n",
    "\n",
    "完成并连同作业缴交此完整的工作表(包括其输出及工作表外的任何支援程式码)。\n",
    "\n",
    "更多详情请参见课程网站上的[assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html)\n",
    "\n",
    "我们已经看到，通过训练一个基于输入图像像素的线性分类器，我们可以在一个图像分类任务上获得合理的性能。\n",
    "\n",
    "在这个练习中，我们将展示我们可以通过训练线性分类器来提高我们的分类性能，不是在原始像素上，而是在从原始像素计算出来的特征上。\n",
    "\n",
    "你这次练习的所有工作都将在这个笔记本上完成。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import numpy as np\n",
    "from cs231n.data_utils import load_CIFAR10\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading extenrnal modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "## Load data\n",
    "Similar to previous exercises, we will load CIFAR-10 data from disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [],
   "source": [
    "from cs231n.features import color_histogram_hsv, hog_feature\n",
    "\n",
    "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n",
    "    # Load the raw CIFAR-10 data\n",
    "#     cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n",
    "    cifar10_dir = 'E:\\cifar-10-batches-py'\n",
    "\n",
    "    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n",
    "    try:\n",
    "       del X_train, y_train\n",
    "       del X_test, y_test\n",
    "       print('Clear previously loaded data.')\n",
    "    except:\n",
    "       pass\n",
    "\n",
    "    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n",
    "    \n",
    "    # Subsample the data\n",
    "    mask = list(range(num_training, num_training + num_validation))\n",
    "    X_val = X_train[mask]\n",
    "    y_val = y_train[mask]\n",
    "    mask = list(range(num_training))\n",
    "    X_train = X_train[mask]\n",
    "    y_train = y_train[mask]\n",
    "    mask = list(range(num_test))\n",
    "    X_test = X_test[mask]\n",
    "    y_test = y_test[mask]\n",
    "    \n",
    "    return X_train, y_train, X_val, y_val, X_test, y_test\n",
    "\n",
    "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "## Extract Features\n",
    "For each image we will compute a Histogram of Oriented\n",
    "Gradients (HOG) as well as a color histogram using the hue channel in HSV\n",
    "color space. We form our final feature vector for each image by concatenating\n",
    "the HOG and color histogram feature vectors.\n",
    "\n",
    "Roughly speaking, HOG should capture the texture of the image while ignoring\n",
    "color information, and the color histogram represents the color of the input\n",
    "image while ignoring texture. As a result, we expect that using both together\n",
    "ought to work better than using either alone. Verifying this assumption would\n",
    "be a good thing to try for your own interest.\n",
    "\n",
    "The `hog_feature` and `color_histogram_hsv` functions both operate on a single\n",
    "image and return a feature vector for that image. The extract_features\n",
    "function takes a set of images and a list of feature functions and evaluates\n",
    "each feature function on each image, storing the results in a matrix where\n",
    "each column is the concatenation of all feature vectors for a single image.\n",
    "\n",
    "对于每个图像，我们将计算一个**方向梯度直方图(HOG)**，\n",
    "\n",
    "以及使用**HSV颜色空间**中的色调通道的**颜色直方图**。\n",
    "\n",
    "我们通过连接**方向梯度直方图**和**颜色直方图**特征向量来形成每个图像的最终特征向量。\n",
    "\n",
    "粗略地说，**方向梯度直方图**应该在忽略颜色信息的情况下捕捉图像的**纹理**，\n",
    "\n",
    "而**颜色直方图**则代表忽略纹理的情况下输入图像的**颜色**。\n",
    "\n",
    "因此，我们期望两者一起使用应该比单独使用更好。\n",
    "\n",
    "为了自己的利益，验证这个假设是一件好事。\n",
    "\n",
    "`hog_feature`和`color_histogram_hsv`函数都对单个图像进行操作，并为该图像返回一个特征向量。\n",
    "\n",
    "extract_features函数获取一组图像和一组特征函数，\n",
    "\n",
    "并对每个图像上的每个特征函数求值，将结果存储在一个矩阵中，其中每一列是单个图像的所有特征向量的连接。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true,
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done extracting features for 1000 / 49000 images\n",
      "Done extracting features for 2000 / 49000 images\n",
      "Done extracting features for 3000 / 49000 images\n",
      "Done extracting features for 4000 / 49000 images\n",
      "Done extracting features for 5000 / 49000 images\n",
      "Done extracting features for 6000 / 49000 images\n",
      "Done extracting features for 7000 / 49000 images\n",
      "Done extracting features for 8000 / 49000 images\n",
      "Done extracting features for 9000 / 49000 images\n",
      "Done extracting features for 10000 / 49000 images\n",
      "Done extracting features for 11000 / 49000 images\n",
      "Done extracting features for 12000 / 49000 images\n",
      "Done extracting features for 13000 / 49000 images\n",
      "Done extracting features for 14000 / 49000 images\n",
      "Done extracting features for 15000 / 49000 images\n",
      "Done extracting features for 16000 / 49000 images\n",
      "Done extracting features for 17000 / 49000 images\n",
      "Done extracting features for 18000 / 49000 images\n",
      "Done extracting features for 19000 / 49000 images\n",
      "Done extracting features for 20000 / 49000 images\n",
      "Done extracting features for 21000 / 49000 images\n",
      "Done extracting features for 22000 / 49000 images\n",
      "Done extracting features for 23000 / 49000 images\n",
      "Done extracting features for 24000 / 49000 images\n",
      "Done extracting features for 25000 / 49000 images\n",
      "Done extracting features for 26000 / 49000 images\n",
      "Done extracting features for 27000 / 49000 images\n",
      "Done extracting features for 28000 / 49000 images\n",
      "Done extracting features for 29000 / 49000 images\n",
      "Done extracting features for 30000 / 49000 images\n",
      "Done extracting features for 31000 / 49000 images\n",
      "Done extracting features for 32000 / 49000 images\n",
      "Done extracting features for 33000 / 49000 images\n",
      "Done extracting features for 34000 / 49000 images\n",
      "Done extracting features for 35000 / 49000 images\n",
      "Done extracting features for 36000 / 49000 images\n",
      "Done extracting features for 37000 / 49000 images\n",
      "Done extracting features for 38000 / 49000 images\n",
      "Done extracting features for 39000 / 49000 images\n",
      "Done extracting features for 40000 / 49000 images\n",
      "Done extracting features for 41000 / 49000 images\n",
      "Done extracting features for 42000 / 49000 images\n",
      "Done extracting features for 43000 / 49000 images\n",
      "Done extracting features for 44000 / 49000 images\n",
      "Done extracting features for 45000 / 49000 images\n",
      "Done extracting features for 46000 / 49000 images\n",
      "Done extracting features for 47000 / 49000 images\n",
      "Done extracting features for 48000 / 49000 images\n",
      "Done extracting features for 49000 / 49000 images\n"
     ]
    }
   ],
   "source": [
    "from cs231n.features import *\n",
    "\n",
    "num_color_bins = 10 # Number of bins in the color histogram\n",
    "feature_fns = [hog_feature, lambda img: color_histogram_hsv(img, nbin=num_color_bins)]\n",
    "X_train_feats = extract_features(X_train, feature_fns, verbose=True)\n",
    "X_val_feats = extract_features(X_val, feature_fns)\n",
    "X_test_feats = extract_features(X_test, feature_fns)\n",
    "\n",
    "# Preprocessing: Subtract the mean feature\n",
    "mean_feat = np.mean(X_train_feats, axis=0, keepdims=True)\n",
    "X_train_feats -= mean_feat\n",
    "X_val_feats -= mean_feat\n",
    "X_test_feats -= mean_feat\n",
    "\n",
    "# Preprocessing: Divide by standard deviation. This ensures that each feature\n",
    "# has roughly the same scale. 这确保了每个特性具有大致相同的范围。\n",
    "std_feat = np.std(X_train_feats, axis=0, keepdims=True)\n",
    "X_train_feats /= std_feat\n",
    "X_val_feats /= std_feat\n",
    "X_test_feats /= std_feat\n",
    "\n",
    "# Preprocessing: Add a bias dimension\n",
    "X_train_feats = np.hstack([X_train_feats, np.ones((X_train_feats.shape[0], 1))])\n",
    "X_val_feats = np.hstack([X_val_feats, np.ones((X_val_feats.shape[0], 1))])\n",
    "X_test_feats = np.hstack([X_test_feats, np.ones((X_test_feats.shape[0], 1))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train SVM on features\n",
    "Using the multiclass SVM code developed earlier in the assignment, train SVMs on top of the features extracted above; \n",
    "\n",
    "this should achieve better results than training SVMs directly on top of raw pixels.\n",
    "\n",
    "使用之前开发的多类支持向量机代码，在上述**特征**的基础上训练支持向量机;\n",
    "\n",
    "这应该比直接在**原始像素**上训练支持向量机得到更好的结果。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-09 reg 5.000000e+04 train accuracy: 0.103776 val accuracy: 0.104000\n",
      "lr 1.000000e-09 reg 5.000000e+05 train accuracy: 0.131061 val accuracy: 0.128000\n",
      "lr 1.000000e-09 reg 5.000000e+06 train accuracy: 0.413082 val accuracy: 0.412000\n",
      "lr 1.000000e-08 reg 5.000000e+04 train accuracy: 0.134633 val accuracy: 0.125000\n",
      "lr 1.000000e-08 reg 5.000000e+05 train accuracy: 0.416796 val accuracy: 0.421000\n",
      "lr 1.000000e-08 reg 5.000000e+06 train accuracy: 0.406735 val accuracy: 0.392000\n",
      "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.417531 val accuracy: 0.417000\n",
      "lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.411041 val accuracy: 0.407000\n",
      "lr 1.000000e-07 reg 5.000000e+06 train accuracy: 0.356796 val accuracy: 0.359000\n",
      "best validation accuracy achieved during cross-validation: 0.421000\n"
     ]
    }
   ],
   "source": [
    "# Use the validation set to tune the learning rate and regularization strength\n",
    "# 使用验证集来调整学习速率和正则化强度\n",
    "from cs231n.classifiers.linear_classifier import LinearSVM\n",
    "\n",
    "learning_rates = [1e-9, 1e-8, 1e-7]\n",
    "regularization_strengths = [5e4, 5e5, 5e6]\n",
    "\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_svm = None\n",
    "\n",
    "################################################################################\n",
    "# TODO:                                                                        #\n",
    "# Use the validation set to set the learning rate and regularization strength. #\n",
    "# This should be identical to the validation that you did for the SVM; save    #\n",
    "# the best trained classifer in best_svm. You might also want to play          #\n",
    "# with different numbers of bins in the color histogram. If you are careful    #\n",
    "# you should be able to get accuracy of near 0.44 on the validation set.       #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 使用验证集设置学习速率和正则化强度。\n",
    "# 这应该与SVM的验证相同;\n",
    "# 保存最佳训练分类器到best_svm中。\n",
    "# 您可能还想在颜色直方图中使用不同数量的箱子。\n",
    "# 如果你很小心的话，你应该能够在验证集上获得接近0.44的精度。\n",
    "pass\n",
    "for rs in regularization_strengths:\n",
    "    for lr in learning_rates:\n",
    "        svm = LinearSVM()\n",
    "        loss_hist = svm.train(X_train_feats, y_train, lr, rs, num_iters=6000)\n",
    "        y_train_pred = svm.predict(X_train_feats)\n",
    "        train_accuracy = np.mean(y_train == y_train_pred)\n",
    "        y_val_pred = svm.predict(X_val_feats)\n",
    "        val_accuracy = np.mean(y_val == y_val_pred)\n",
    "        if val_accuracy > best_val:\n",
    "            best_val = val_accuracy\n",
    "            best_svm = svm           \n",
    "        results[(lr,rs)] = train_accuracy, val_accuracy\n",
    "                \n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    train_accuracy, val_accuracy = results[(lr, reg)]\n",
    "    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n",
    "                lr, reg, train_accuracy, val_accuracy))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.419\n"
     ]
    }
   ],
   "source": [
    "# Evaluate your trained SVM on the test set\n",
    "y_test_pred = best_svm.predict(X_test_feats)\n",
    "test_accuracy = np.mean(y_test == y_test_pred)\n",
    "print(test_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 80 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# An important way to gain intuition about how an algorithm works is to\n",
    "# visualize the mistakes that it makes. In this visualization, we show examples\n",
    "# of images that are misclassified by our current system. The first column\n",
    "# shows images that our system labeled as \"plane\" but whose true label is\n",
    "# something other than \"plane\".\n",
    "# 获得算法工作原理的直觉的一个重要方法是将它所犯的错误形象化。\n",
    "# 在这个可视化中，我们展示了被当前系统错误分类的图像示例。\n",
    "# 第一列显示了我们的系统标记为“plane”，但其真正的标记不是“plane”。\n",
    "examples_per_class = 8\n",
    "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n",
    "for cls, cls_name in enumerate(classes):\n",
    "    idxs = np.where((y_test != cls) & (y_test_pred == cls))[0]\n",
    "    idxs = np.random.choice(idxs, examples_per_class, replace=False)\n",
    "    for i, idx in enumerate(idxs):\n",
    "        plt.subplot(examples_per_class, len(classes), i * len(classes) + cls + 1)\n",
    "        plt.imshow(X_test[idx].astype('uint8'))\n",
    "        plt.axis('off')\n",
    "        if i == 0:\n",
    "            plt.title(cls_name)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "### Inline question 1:\n",
    "Describe the misclassification results that you see. Do they make sense?\n",
    "\n",
    "\n",
    "$\\color{blue}{\\textit Your Answer:}$\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Neural Network on image features\n",
    "Earlier in this assigment we saw that training a two-layer neural network on raw pixels achieved better classification performance than linear classifiers on raw pixels. In this notebook we have seen that linear classifiers on image features outperform linear classifiers on raw pixels. \n",
    "\n",
    "For completeness, we should also try training a neural network on image features. This approach should outperform all previous approaches: you should easily be able to achieve over 55% classification accuracy on the test set; our best model achieves about 60% classification accuracy.\n",
    "\n",
    "在此之前，我们看到在原始像素上训练一个**两层神经网络**比在原始像素上训练**线性分类器**获得更好的分类性能。\n",
    "\n",
    "在这个本子中，我们已经看到线性分类器在**图像特征**上胜过线性分类器在**原始像素**上。\n",
    "\n",
    "为了完整性，我们也应该尝试训练一个**神经网络**的**图像特征**。\n",
    "\n",
    "这种方法应该优于所有以前的方法:\n",
    "\n",
    "您应该能够轻松地在测试集上获得超过55%的分类精度;\n",
    "\n",
    "我们的最佳模型达到了60%的分类准确率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(49000, 155)\n",
      "(49000, 154)\n"
     ]
    }
   ],
   "source": [
    "# Preprocessing: Remove the bias dimension\n",
    "# Make sure to run this cell only ONCE\n",
    "print(X_train_feats.shape)\n",
    "X_train_feats = X_train_feats[:, :-1]\n",
    "X_val_feats = X_val_feats[:, :-1]\n",
    "X_test_feats = X_test_feats[:, :-1]\n",
    "\n",
    "print(X_train_feats.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": [
     "code"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\zzz\\Desktop\\spring1819_assignment123\\assignment1\\cs231n\\classifiers\\neural_net.py:130: RuntimeWarning: divide by zero encountered in log\n",
      "  loss = -np.sum(np.log(softmax_output[range(N), list(y)]))\n",
      "C:\\Users\\zzz\\Desktop\\spring1819_assignment123\\assignment1\\cs231n\\classifiers\\neural_net.py:125: RuntimeWarning: overflow encountered in subtract\n",
      "  shift_scores = scores - np.max(scores, axis = 1).reshape(-1,1)\n",
      "C:\\Users\\zzz\\Desktop\\spring1819_assignment123\\assignment1\\cs231n\\classifiers\\neural_net.py:125: RuntimeWarning: invalid value encountered in subtract\n",
      "  shift_scores = scores - np.max(scores, axis = 1).reshape(-1,1)\n",
      "C:\\Users\\zzz\\Desktop\\spring1819_assignment123\\assignment1\\cs231n\\classifiers\\neural_net.py:154: RuntimeWarning: invalid value encountered in greater\n",
      "  dh_ReLu = (h_output > 0) * dh\n",
      "C:\\Users\\zzz\\Desktop\\spring1819_assignment123\\assignment1\\cs231n\\classifiers\\neural_net.py:132: RuntimeWarning: overflow encountered in double_scalars\n",
      "  loss +=  0.5* reg * (np.sum(W1 * W1) + np.sum(W2 * W2))\n",
      "D:\\anacondathree\\lib\\site-packages\\numpy\\core\\fromnumeric.py:86: RuntimeWarning: overflow encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr 1.000000e-02 reg 1.000000e-03 val accuracy: 0.198000\n",
      "lr 1.000000e-02 reg 5.000000e-03 val accuracy: 0.180000\n",
      "lr 1.000000e-02 reg 1.000000e-02 val accuracy: 0.087000\n",
      "lr 1.000000e-02 reg 1.000000e-01 val accuracy: 0.079000\n",
      "lr 1.000000e-02 reg 5.000000e-01 val accuracy: 0.078000\n",
      "lr 1.000000e-02 reg 1.000000e+00 val accuracy: 0.098000\n",
      "lr 1.000000e-01 reg 1.000000e-03 val accuracy: 0.529000\n",
      "lr 1.000000e-01 reg 5.000000e-03 val accuracy: 0.518000\n",
      "lr 1.000000e-01 reg 1.000000e-02 val accuracy: 0.505000\n",
      "lr 1.000000e-01 reg 1.000000e-01 val accuracy: 0.423000\n",
      "lr 1.000000e-01 reg 5.000000e-01 val accuracy: 0.105000\n",
      "lr 1.000000e-01 reg 1.000000e+00 val accuracy: 0.102000\n",
      "lr 5.000000e-01 reg 1.000000e-03 val accuracy: 0.583000\n",
      "lr 5.000000e-01 reg 5.000000e-03 val accuracy: 0.558000\n",
      "lr 5.000000e-01 reg 1.000000e-02 val accuracy: 0.533000\n",
      "lr 5.000000e-01 reg 1.000000e-01 val accuracy: 0.391000\n",
      "lr 5.000000e-01 reg 5.000000e-01 val accuracy: 0.107000\n",
      "lr 5.000000e-01 reg 1.000000e+00 val accuracy: 0.098000\n",
      "lr 1.000000e+00 reg 1.000000e-03 val accuracy: 0.587000\n",
      "lr 1.000000e+00 reg 5.000000e-03 val accuracy: 0.558000\n",
      "lr 1.000000e+00 reg 1.000000e-02 val accuracy: 0.536000\n",
      "lr 1.000000e+00 reg 1.000000e-01 val accuracy: 0.358000\n",
      "lr 1.000000e+00 reg 5.000000e-01 val accuracy: 0.157000\n",
      "lr 1.000000e+00 reg 1.000000e+00 val accuracy: 0.112000\n",
      "lr 5.000000e+00 reg 1.000000e-03 val accuracy: 0.087000\n",
      "lr 5.000000e+00 reg 5.000000e-03 val accuracy: 0.087000\n",
      "lr 5.000000e+00 reg 1.000000e-02 val accuracy: 0.087000\n",
      "lr 5.000000e+00 reg 1.000000e-01 val accuracy: 0.087000\n",
      "lr 5.000000e+00 reg 5.000000e-01 val accuracy: 0.087000\n",
      "lr 5.000000e+00 reg 1.000000e+00 val accuracy: 0.087000\n",
      "best validation accuracy achieved during cross-validation: 0.587000\n"
     ]
    }
   ],
   "source": [
    "from cs231n.classifiers.neural_net import TwoLayerNet\n",
    "\n",
    "input_dim = X_train_feats.shape[1]\n",
    "hidden_dim = 500\n",
    "num_classes = 10\n",
    "\n",
    "net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n",
    "best_net = None\n",
    "\n",
    "################################################################################\n",
    "# TODO: Train a two-layer neural network on image features. You may want to    #\n",
    "# cross-validate various parameters as in previous sections. Store your best   #\n",
    "# model in the best_net variable.                                              #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "# 在图像特征上训练一个双层神经网络。\n",
    "# 您可能想要交叉验证前面几节中提到的各种参数。\n",
    "# 将您的最佳模型存储在best_net变量中。\n",
    "pass\n",
    "results = {}\n",
    "best_val = -1\n",
    "best_net = None\n",
    "\n",
    "learning_rates = [1e-2 ,1e-1, 5e-1, 1, 5]\n",
    "regularization_strengths = [1e-3, 5e-3, 1e-2, 1e-1, 0.5, 1]\n",
    "\n",
    "for lr in learning_rates:\n",
    "    for reg in regularization_strengths:\n",
    "        net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n",
    "        # Train the network\n",
    "        stats = net.train(X_train_feats, y_train, X_val_feats, y_val,\n",
    "                        num_iters=1500, batch_size=200,\n",
    "                        learning_rate=lr, learning_rate_decay=0.95,\n",
    "                        reg= reg, verbose=False)\n",
    "        val_acc = (net.predict(X_val_feats) == y_val).mean()\n",
    "        if val_acc > best_val:\n",
    "            best_val = val_acc\n",
    "            best_net = net         \n",
    "        results[(lr,reg)] = val_acc\n",
    "\n",
    "# Print out results.\n",
    "for lr, reg in sorted(results):\n",
    "    val_acc = results[(lr, reg)]\n",
    "    print('lr %e reg %e val accuracy: %f' % (lr, reg,  val_acc))\n",
    "    \n",
    "print('best validation accuracy achieved during cross-validation: %f' % best_val)\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.568\n"
     ]
    }
   ],
   "source": [
    "# Run your best neural net classifier on the test set. You should be able\n",
    "# to get more than 55% accuracy.\n",
    "# 在测试集中运行你最好的神经网络分类器。\n",
    "# 你应该能够得到超过55%的准确率。\n",
    "test_acc = (best_net.predict(X_test_feats) == y_test).mean()\n",
    "print(test_acc)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
